package com.capgemini;

import java.sql.Date;
import java.sql.Time;
import java.util.List;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.util.Bytes;

import com.capgemini.daos.Dao;
import com.capgemini.daos.PersonDao;
import com.capgemini.daos.TournamentDao;
import com.capgemini.data.Athlete;
import com.capgemini.data.Discipline;
import com.capgemini.data.OlympicAdress;
import com.capgemini.data.Performance;
import com.capgemini.data.Tournament;
import com.capgemini.data.Trainer;

public class Main {

	/**
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		// example1();
		// example2();
		withoutJPA();

	}

	public static void withoutJPA() throws Exception {
		String[] familys = { "Info", "Performance" };
		Dao.creatTable("Tournament", familys);
		TournamentDao tourdao = new TournamentDao();
		String[] familys2 = { "PersonInfo", "AthleteInfo", "TrainerInfo",
				"Performance", "Athlete", "Trainer", "OlympicAddress" };
		Dao.creatTable("Person", familys2);
		PersonDao persdao = new PersonDao();

		Tournament os = new Tournament("Olympic Games", "Athens", 24, new Date(
				104, 6, 17), new Date(104, 6, 20), Discipline.SPRINT200M);
		tourdao.addRow(os);
		os = tourdao.getRecord(String.valueOf(1));
		Performance perf2 = new Performance(new Time(9750000), 2, false, os);
		Performance perf1 = new Performance(new Time(9630000), 1, false, os);
		os.addPerformance(perf2);
		os.addPerformance(perf1);
		tourdao.addRow(os);
		tourdao.getAllRecord("Tournament");
		List<Tournament> tours = tourdao.getRecords();
		os = tourdao.getRecord(String.valueOf((1)));

		Athlete bolt = new Athlete("Usain", "Bolt", new Date(80, 0, 27),
				"Jamaica", Discipline.SPRINT100M, 1);
		bolt.setAdress(new OlympicAdress("Bessenveldstraat", 19, "Diegem"));
		bolt.addDopingHistory("2000: EPO");
		bolt.addDopingHistory("2001: CERA");
		persdao.addRow(bolt);

		Trainer delb = new Trainer("Anton", "Del Bosque", new Date(52, 1, 14),
				"Brasil", true, "main coach");
		persdao.addRow(delb);
		bolt = (Athlete) persdao.getRecord("atl/" + String.valueOf(1));
		delb = (Trainer) persdao.getRecord("tra/" + String.valueOf(2));
		persdao.getAllRecord("Person");
		bolt.addTrainer(delb.getId());
		persdao.addRow(bolt);
		bolt = (Athlete) persdao.getRecord("atl/" + String.valueOf(1));
		os.getPerformances().iterator().next().setAthlete(bolt.getId());
		tourdao.addRow(os);
		bolt = (Athlete) persdao.getRecord("atl/" + String.valueOf(1));
		// bolt.setTrainers(null);
		// persdao.addRow(bolt);
		delb = (Trainer) persdao.getRecord("tra/" + String.valueOf(2));
		// tourdao.delRecord("Tournament", String.valueOf(1));
		// persdao.delRecord("Person", "tra/" + String.valueOf(2));
	}

	public static void example1() throws Exception {
		// You need a configuration object to tell the client where to connect.
		// When you create a HBaseConfiguration, it reads in whatever you've set
		// into your hbase-site.xml and in hbase-default.xml, as long as these
		// can be found on the CLASSPATH
		Configuration config = HBaseConfiguration.create();

		String tablename = "myHBaseTable";
		String[] familys = { "myFamily" };
		Dao.creatTable(tablename, familys);

		// This instantiates an HTable object that connects you to the
		// "myHBaseTable" table.
		HTable table = new HTable(config, "myHBaseTable");

		// To add to a row, use Put. A Put constructor takes the name of the row
		// you want to insert into as a byte array. In HBase, the Bytes class
		// has utility for converting all kinds of java types to byte arrays. In
		// the below, we are converting the String "myRow" into a byte
		// array to use as a row key for our update. Once you have a Put
		// instance, you can adorn it by setting the names of columns you want
		// to update on the row, the timestamp to use in your update, etc.
		// If no timestamp, the server applies current time to the edits.
		Put p = new Put(Bytes.toBytes("myRow"));

		// To set the value you'd like to update in the row 'myRow',
		// specify the column family, column qualifier, and value of the table
		// cell you'd like to update. The column family must already exist
		// in your table schema. The qualifier can be anything.
		// All must be specified as byte arrays as HBase is all about byte
		// arrays. Lets pretend the table 'myHBaseTable' was created
		// with a family 'myFamily'.
		p.add(Bytes.toBytes("myFamily"), Bytes.toBytes("Qualifier1"),
				Bytes.toBytes("Value1"));

		// Once you've adorned your Put instance with all the updates you want
		// to make, to commit it do the following
		// (The HTable#put method takes the Put instance you've been building
		// and pushes the changes you made into HBase)
		table.put(p);

		// Now, to retrieve the data we just wrote. The values that come back
		// are Result instances. Generally, a Result is an object that will
		// package up the HBase return into the form you find most palatable.
		Get g = new Get(Bytes.toBytes("myRow"));
		Result r = table.get(g);
		byte[] value = r.getValue(Bytes.toBytes("myFamily"),
				Bytes.toBytes("someQualifier"));

		// If we convert the value bytes, we should get back 'Some Value', the
		// value we inserted at this location.
		String valueStr = Bytes.toString(value);
		System.out.println("GET: " + valueStr);

		// Sometimes, you won't know the row you're looking for. In this case,
		// you use a Scanner. This will give you cursor-like interface to the
		// contents of the table. To set up a Scanner, do like you did above
		// making a Put and a Get, create a Scan. Adorn it with column names,
		// etc.
		Scan s = new Scan();
		s.addColumn(Bytes.toBytes("myFamily"), Bytes.toBytes("someQualifier"));
		ResultScanner scanner = table.getScanner(s);
		try {
			// Scanners return Result instances.
			// Now, for the actual iteration. One way is to use a while loop
			// like so:
			for (Result rr = scanner.next(); rr != null; rr = scanner.next()) {
				// print out the row we found and the columns we were looking
				// for
				System.out.println("Found row: " + rr);
			}

			// The other approach is to use a foreach loop. Scanners are
			// iterable!
			for (Result rr : scanner) {
				System.out.println("Found row: " + rr);
			}
		} finally {
			// Make sure you close your scanners when you are done!
			// Thats why we have it inside a try/finally clause
			scanner.close();
		}

		s = new Scan();
		s.addColumn(Bytes.toBytes("myFamily"), Bytes.toBytes("someQualifier"));
		scanner = table.getScanner(s);
		try {
			// The other approach is to use a foreach loop. Scanners are
			// iterable!
			for (Result rr : scanner) {
				System.out.println("Found row: " + rr);
			}
		} finally {
			// Make sure you close your scanners when you are done!
			// Thats why we have it inside a try/finally clause
			scanner.close();
		}
	}

	public static void example2() {
		try {
			String tablename = "scores";
			String[] familys = { "grade", "course" };
			Dao.creatTable(tablename, familys);

			// add record zkb
			Dao.addRecord(tablename, "zkb", "grade", "", "5");
			Dao.addRecord(tablename, "zkb", "course", "", "90");
			Dao.addRecord(tablename, "zkb", "course", "math", "97");
			Dao.addRecord(tablename, "zkb", "course", "art", "87");
			// add record baoniu
			Dao.addRecord(tablename, "baoniu", "grade", "", "4");
			Dao.addRecord(tablename, "baoniu", "course", "math", "89");

			System.out.println("===========get one record========");
			Dao.getOneRecord(tablename, "zkb");

			System.out.println("===========show all record========");
			Dao.getAllRecord(tablename);

			System.out.println("===========del one record========");
			Dao.delRecord(tablename, "baoniu");
			Dao.getAllRecord(tablename);

			System.out.println("===========show all record========");
			Dao.getAllRecord(tablename);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
